v2.1.0-beta: dependency upgrade, CTLie integration, test rework - #826

The package did not load: `UndefVarError: AbstractDiscretizer not defined in
CTDirect`. Three symbol families physically changed package while
OptimalControl stayed pinned at CTBase 0.18.8 / CTModels 0.10.1.

Re-point every import at its *owning* submodule, per the Handbook `modules.md`
rule:

  CTFlows            → CTBase.Data      the type vocabulary `Flow` dispatches on
  CTFlows            → CTLie            ad / Lift / Poisson / ∂ₜ / @lie
  CTSolvers          → CTBase.Strategies, CTBase.Options, CTBase.Orchestration
  CTDirect           → CTSolvers.DOCP   AbstractDiscretizer, discretize
  CTModels           → Components / Models / Solutions / Building / Init

New `src/imports/{ctlie,adnlpmodels,ad}.jl`. The last two exist for their
imports alone: a `[deps]` entry arms no extension — Julia fires one when the
trigger package is *loaded*. ADNLPModels and DifferentiationInterface are in
`[deps]` precisely because CTSolvers' and CTBase's extensions need them, so we
must load them or ship a dead capability. `test/suite/extensions/` guards this.

Also re-points ~45 qualified sites across `src/helpers/` and `src/solve/`.
Argument annotations are load-fatal while bodies fail only on first call, so
precompilation proves nothing here; verified by forcing the lazy registry,
`describe`, the print helpers and a descriptive `solve` end to end.

Two API changes are not renames, and are handled rather than papered over:

- `CTSolvers.Strategies.get_parameter_type` → `CTBase.Strategies.parameter`
  returns `nothing` no longer: it throws `NotImplemented` when a strategy has
  not implemented the (optional) parameter contract. `print.jl` is display
  code and must not be what crashes on a third-party strategy, hence the new
  `_strategy_parameter` shim.
- `time` and `success` are dropped from the re-export surface. Both resolve to
  bare `Base` functions: `CTModels.Components` extends `Base.time` without
  exporting it, and `CTModels.Solutions` exports the *name* `success` while
  defining no method for it — `success(sol)` was always a `MethodError`. The
  real accessor is `successful`.

Refs #815

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

…lity

The nine problems returned bare NamedTuples with **no common schema** — some
carried `F0`/`F1`, some `x0`/`xf`/`t0`/`tf`, some `p_expected`. Anything
generic over them had to guess.

`TestProblem` promotes the four fields every problem has and keeps the rest in
`data`, verbatim: no information was dropped, it moved one level down.

Each problem now builds two ways, `:abstract` (the `@def` DSL) and
`:functional` (the `CTModels.Building` API), which is what makes a
form-equivalence test possible at all. 18/18 build.

Also adds a `methods` field, prompted by review: not every problem can be
attacked both ways. The quadrotor has no exploitable extremal structure and no
reference costate, so it is a direct fixture only — and nothing said so. A
shooting sweep would have had to skip it by name, a list that rots.

The claim is self-enforcing rather than documentary: declaring `:indirect`
without a `p0` in `data` is rejected by the constructor. Selection goes through
`problems_for(:indirect)`.

    indirect: goddard, double_integrator_{time,energy,energy_constrained}
    direct:   all nine

The indirect tests now read `p0` and the switching times from `data` instead of
restating them, so the reference data cannot drift away from the model that is
supposed to satisfy it.

Two things the functional API insists on, both easy to get wrong:
`time_dependence!` is mandatory before `build`, and a control-free problem must
*omit* `control!` — `control!(pre, 0)` is rejected.

Refs #815

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Four new groups, each covering a boundary OptimalControl owns rather than one
its dependencies already test.

**suite/problems/test_forms_equivalent.jl** — `@def` is sugar over
`CTModels.Building`, and if the sugar and the API drift apart one of them is
lying. One body over all nine problems: dimensions, horizon kind, cost,
dynamics at a sample point, constraint dimensions. The `definition` difference
is asserted *as* a difference rather than skipped.

**suite/problems/test_hamiltonian_type.jl** — `:total` and `:partial` agree
wherever the control law is stationary for H̃, which is everywhere in the
indirect suite, so it is easy to believe they are redundant. They are not, and
this pins down why: on the energy double integrator with u = p₂ + 1 (not the
minimiser),

    :partial → ẋ₂ = u = p₂ + 1        ("apply this feedback")
    :total   → ẋ₂ = u + (∂H̃/∂u)(∂u/∂p₂) = p₂   (the perturbation cancels)

Both correct for what they compute; picking the wrong one on a non-stationary
law silently integrates different dynamics. Also runs the stationary cases
across both front ends, including Goddard's constrained arc.

**suite/flows/test_flow_api.jl** — the constructor grid, the three `constraint`
spellings including the `Symbol` label that reuses the OCP's own declared
constraint, and the calling convention.

Two things found while writing it:

- `Flow(ocp, ClosedLoop/OpenLoop)` returns a *state* flow with no costate, not
  a rejection — the report had this as a `PreconditionError`.
- `is_autonomous` strips the time argument uniformly across law kinds, so an
  autonomous `OpenLoop` is called with **no arguments at all**. `OpenLoop(t ->
  0.0)` reads as correct and is a `MethodError` at integration time. The full
  arity table is now pinned; the design question is raised neutrally in
  control-toolbox/CTBase.jl#515.

**suite/shape/test_shape_contract.jl** — deliberately *not* a copy of
CTDirect's exhaustive per-scheme version. What is ours is the contract
surviving the whole `solve` stack, the same contract on the indirect path
(CTFlows has no assertion for it, only defensive `isa Number ? … : …[1]`
guards that tolerate either shape), and the two paths agreeing — the seam
nothing upstream can check.

`test/helpers/shooting.jl` ports `test_shooting` from CTFlows so the indirect
checks here ask the same two questions upstream does: residual at the known
solution (a wrong derivation still converges, just to the wrong thing), and
convergence from a perturbed guess.

Refs #815

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

…and :sciml

`describe(:id)` previously only knew the solve registry (discretizer, NLP
modeler, NLP solver) — `:di` and `:sciml`, from CTFlows' flow registry, were
unreachable through the single-argument convenience wrapper. The integrator
and the AD backend are strategies in the control-toolbox sense like any
other, so their options should be inspectable the same way (.reports item).

`get_full_strategy_registry()` merges the two registries rather than falling
back with try/catch: a fallback would swallow the genuine "unknown strategy"
error on a typo and surface whatever the second registry raised instead. The
merge is total here because the two registries are measurably disjoint — no
shared id, no shared family, `:cpu`/`:gpu` bound to the same types on both
sides — asserted in test_describe.jl rather than assumed.

Reaching into StrategyRegistry's two fields to build the union is deliberate
but temporary, and skips the validation create_registry performs within one
registry — exactly what a cross-registry union should re-check. Requested
upstream as CTBase#517 (Base.merge for StrategyRegistry); switch once
released.

Along the way: describe(:sciml) turns out to throw FieldError on any
registry that contains it, and takes describe(:cpu)/describe(:gpu) down with
it — CTBase's _strategy_base_name only handles strategies with at most two
type parameters, and SciML has four. Root cause and fix are upstream
(CTBase#516); CTSolvers#191 tracks the missing describe coverage for the
Integrators family that let it through. The three affected assertions here
are @test_broken, not skipped, so the fix landing flips them to unexpected
passes and fails the suite — the reminder to promote them.

Full suite: 23 passed + 3 broken (new file), no regressions in the
registry-dependent groups (helpers/print, helpers/registry, helpers/methods,
reexport/{ctbase,ctsolvers,optimalcontrol}: 552/552).

Refs: control-toolbox/CTBase.jl#516, control-toolbox/CTBase.jl#517,
control-toolbox/CTSolvers.jl#191

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Not a silent absorption any more: a third-party strategy that never
implements `CTBase.Strategies.parameter` still falls back to `nothing`
(display must not crash the caller's solve over an optional, cosmetic
detail), but now says so once per type via `@warn ... maxlog=1`, keyed on
the strategy type so a solve loop doesn't spam.

Confirmed via the existing FakeDiscretizerNoParam/FakeModelerNoParam/
FakeSolverNoParam fixtures in test_print.jl, which already exercise this
exact path: one warning per type, test_print.jl still 87/87.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Each indirect fixture (Goddard, the three double-integrator variants) now
carries its own shoot_builder — a closure of signature
`(; hamiltonian_type=:total) -> (shoot!, ξ_exact, ξ_guess)` — on TestProblem,
next to the problem itself. Quadrotor's stays `nothing`: no exploitable
extremal structure, and TestProblem's own constructor now enforces the claim
(`:indirect` requires shoot_builder !== nothing, not `data.p0`).

One generic suite/indirect/test_shooting_sweep.jl replaces three
hand-written files (test_goddard.jl, test_double_integrator_{time,energy}.jl),
looping over problems_for(:indirect) across both forms. It also adds the
Newton-from-a-perturbed-guess half none of the three ever exercised — only
the residual at the known reference was checked before.

Found along the way: the same derivations were ALSO written a second time in
suite/problems/test_hamiltonian_type.jl, independently. That file now
consumes the same shoot_builder(; hamiltonian_type=ht), keeping only what is
genuinely its own — sweeping :total/:partial and the "they agree/disagree"
assertions.

The one guard-rail assertion from the three deleted files that was not
already covered generically elsewhere (`variable=` mandatory when *omitted*
on a NonFixed flow) moved to test_flow_api.jl, next to its mirror image
("no variable on a Fixed flow") which already lived there. Everything else
they carried (constraint/multiplier pairing, trajectory form, Lift-vs-
Hamiltonian semantics) was redundant with existing generic coverage and is
gone rather than moved.

Full suite: 2166 passed, 5 broken (2 device/capability skips + 3 pre-existing
@test_broken in test_describe.jl, unrelated to this change), zero
regressions.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Consumes CTBase 0.28.9-beta: an open-loop control depends only on time,
u(t) (or u(t, v)) — autonomy is a property of the OCP, not of the control,
so OpenLoop no longer offers is_autonomous as a real choice the way
ClosedLoop/DynClosedLoop do. is_autonomous is kept as a misuse-detector
keyword that now warns rather than doing nothing.

test_flow_api.jl:
- "control-law kinds select different flows": drop the now-inert
  is_autonomous=false on the OpenLoop construction, rewrite the comment that
  described the old trap (an autonomous OpenLoop called with no arguments at
  all) since the trap no longer exists.
- "is_autonomous governs the law's arity": the OpenLoop row of the arity
  table loses its autonomous variant — there is only one spelling now. Added
  a dedicated regression test that the old zero-argument spelling
  (OpenLoop(() -> 0.0)) still fails, loudly, with MethodError at
  integration time rather than constructing silently.

BREAKING.md / CHANGELOG.md also completed with everything landed since the
first v2.1.0-beta entries were written: describe() now covers the full
strategy surface (:di, :sciml, merging the solve and flow registries via
CTBase's Base.merge), the non-throwing parameter(T, default) accessor
package authors can use instead of a hand-rolled try/catch, and this
OpenLoop change.

CTFlows' own six zero-argument OpenLoop test sites are fixed separately, on
their own branch/PR, not here.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Both jobs need use_ct_registry: true — this branch depends on beta versions
(CTBase, CTFlows, CTSolvers, CTLie, ...) that only exist in the
control-toolbox registry, not General. Drops the explicit julia `versions`
pin and adds windows-latest to the CPU job's runner matrix.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Julia 1.10's inference widens `_extract_kwarg`'s return type to
Union{Nothing,AbstractDiscretizer} instead of narrowing to the concrete
branch actually taken, making @inferred fail spuriously — a real
inference-precision difference between 1.10 and 1.11, not a bug in
_extract_kwarg. The allocation checks (@allocated) are unaffected and
still run unconditionally on both versions.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Temporary — points the CPU job at fix/windows-pkg-cli-git instead of
main so this branch's Windows CI can confirm CTActions#67 before it
merges. Revert to @main once that PR lands.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Windows CI confirmed green on fix/windows-pkg-cli-git (git_cli input on
julia-buildpkg). CTActions#67 is merged, so revert to @main.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>